package com.example.demo.zaqizabatest;

import cn.hutool.core.map.MapUtil;
import com.example.demo.test2.entity.Test2;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName Test11
 * @Author lys4134
 * @Date 2021/05/31 15:38:13
 * @Description Test11
 * @Version 1.0
 **/
@SuppressWarnings("AlibabaLowerCamelCaseVariableNaming")
public class Test11 {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        Calendar instance = Calendar.getInstance();
        list.add(new Person("aaa", instance.getTime()));
        instance.add(Calendar.DAY_OF_MONTH, -1);
        list.add(new Person("bbb", instance.getTime()));
        instance.add(Calendar.HOUR_OF_DAY, -1);
        list.add(new Person("bbb111", instance.getTime()));
        instance.add(Calendar.DAY_OF_MONTH, -1);
        list.add(new Person("ccc", instance.getTime()));
        System.out.println(list.toString());
        final Map<Integer, List<Person>> collect = list.stream()
                .collect(Collectors.groupingBy(item -> {
            return item.getDate().getDay() / 2;
        }));

        for (Integer integer : collect.keySet()) {
            System.out.println(integer + "--->>>" + collect.get(integer));
        }


//        Integer a = 129;
//        Integer b = 129;
//        System.out.println(a.equals(b));
//
//
//        int[] weight = {5, 2, 1, 3, 2};
//        int[] value = {20, 12, 10, 20, 15};
//
//
//        ZeroOnePack(5, weight, value);
//        int[] nums = {-2, -1, -3, -4, -1, -2, -1, -5, -4};
//        System.out.println(subSum(nums));
//        int[][] grids = new int[][]{{1,3,1},{1,5,1}, {4,2,1}};
//        System.out.println(maxValue(grids));
    }

    /**
     * 0-1背包问题
     *
     * @param V      背包容量
     *               //     * @param N	物品种类
     * @param weight 物品重量
     * @param value  物品价值
     * @return
     */
    public static int ZeroOnePack(int V, int[] weight, int[] value) {
        int N = weight.length;
        //初始化动态规划数组
        int[][] dp = new int[N + 1][V + 1];
        //为了便于理解,将dp[i][0]和dp[0][j]均置为0，从1开始计算
        //i代表第几件物品，j代表当前背包容量
        for (int i = 0; i < N + 1; i++) {
            for (int j = 0; j < V + 1; j++) {
                //如果第i件物品的重量大于背包容量j,则不装入背包
                //由于weight和value数组下标都是从0开始,故注意第i个物品的重量为weight[i-1],价值为value[i-1]
                if (i == 0 || j == 0) {
                    dp[i][j] = 0;
                } else {
                    if (weight[i - 1] > j) {
                        dp[i][j] = dp[i - 1][j];
                    } else
                        // 当第i件可以加入，那就比较i-1，j时候的值与i-1,j-weight[i-1] + value[i-1]的值
                    {
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
                    }
                }

            }
        }
        //则容量为V的背包能够装入物品的最大值为
        for (int i = 0; i <= N; i++) {
            for (int j = 0; j <= V; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println();
        }

        int maxValue = dp[N][V];
        //逆推找出装入背包的所有商品的编号
        int j = V;
        String numStr = "";
        for (int i = N; i > 0; i--) {
            //若果dp[i][j]>dp[i-1][j],这说明第i件物品是放入背包的
            if (dp[i][j] > dp[i - 1][j]) {
                numStr = i + " " + numStr;
                j = j - weight[i - 1];
            }
            if (j == 0) {
                break;
            }
        }
        System.out.println(numStr);
        return maxValue;
    }


    /**
     * 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
     * <p>
     * 要求时间复杂度为O(n)。
     * <p>
     *  
     * <p>
     * 示例1:
     * <p>
     * 输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
     * 输出: 6
     * 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
     * <p>
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     */
    public static int subSum(int[] nums) {
//        int max = Integer.MIN_VALUE;
//        int sum = 0;
//        for (int num : nums) {     // 若当前遍历到num，sum是以num为右端的最大子数组和
//            if (sum > 0) sum += num;
//            else sum = num;
//            max = Math.max(max, sum);
//        }
//        return max;


        //每个元素用来记录连续最大和
        int[] dp = new int[nums.length];
        int max = nums[0];
        dp[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (dp[i - 1] > 0) {
                dp[i] = dp[i - 1] + nums[i];
            } else {
                dp[i] = nums[i];
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }

    /**
     *
     *
     * 在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。
     * 你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。
     * 给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？
     *
     *  
     *
     * 示例 1:
     *
     * 输入:
     * [
     *   [1,3,1],
     *   [1,5,1],
     *   [4,2,1]
     * ]
     * 输出: 12
     * 解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物
     *
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     *
     */
    public static int maxValue(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int[][] dp = new int[n][m];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                if(i == 0 && j != 0){
                    dp[i][j] = grid[i][j] + dp[i][j-1];
                } else if(i != 0 && j == 0){
                    dp[i][j] = dp[i-1][j] + grid[i][j];
                } else if(i == 0 && j == 0){
                    dp[i][j] = grid[0][0];
                } else {
                    dp[i][j] = grid[i][j] + Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[n-1][m-1];
    }

    /**
     * 0-1背包的优化解法
     * 思路：
     * 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值
     * 用逆序来实现
     */
    public static int ZeroOnePack2(int V, int N, int[] weight, int[] value) {
        //动态规划
        int[] dp = new int[V + 1];
        for (int i = 1; i < N + 1; i++) {
            //逆序实现
            for (int j = V; j >= weight[i - 1]; j--) {
                dp[j] = Math.max(dp[j - weight[i - 1]] + value[i - 1], dp[j]);
            }
        }
        return dp[V];
    }


//    public static void main(String[] args) throws ParseException {
//        Aaa aaa = new Aaa();
//        aaa.setName("111");
//        bbb(aaa);
//        System.out.println(aaa);
//
////        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ");
////        SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
////        Date createTime = null;
////        try {
////            createTime = df.parse("2021-06-03T09:32:31Z");
////        } catch (Exception e) {
////            e.printStackTrace();
////        }
////        java.text.SimpleDateFormat formatter = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss");
////        java.text.SimpleDateFormat formatter1 = new SimpleDateFormat( "yyyy-MM-dd'T'hh:mm:ssZ");
////        String s= "2021-06-03 09:32:31";
////        Date date =  formatter.parse(s);
////        Date date1 = formatter1.parse("2021-06-03T09:32:31Z");
////        createTime = new Date("2021-06-03 09:32:31");
////        System.out.println();
////        String str = "http://192.168.100.75:8080/#/cloud-host-application/";
////        String url1 = str.substring(0, str.indexOf("#"));
////        String url2 = str.substring(str.indexOf("#"));
////        System.out.println(url1 + "?timeStamp="+ System.currentTimeMillis() + url2 );
//    }

    private static void bbb(Aaa aaa) {
        aaa.setPwd("111");
    }
}
